package com.syedu.day05;

import java.util.Arrays;

/**
 * description：数组工具类(默认都是int[]数组)
 * @author Administrator
 * @date 2022/3/10 16:08
 */
public class ArrUtil {
    public static void main(String[] args) {
        //int[] arr = {8, 3, 1, 1, 2, 3, 1, 7, 4, 4};

        int[] arr = null;

        Integer maxElement = maxElement(arr);
        System.out.println(maxElement);
        Integer minElement = minElement(arr);
        System.out.println(minElement);

       /* int[] addElement = addElement(arr, 3, 888);
        System.out.println(Arrays.toString(addElement));*/

       /* int[] deleteElementByIndex = deleteElementByIndex(arr, 2);
        System.out.println(Arrays.toString(deleteElementByIndex));*/

        /*int[] deleteElementByTarget = deleteElementByTarget(arr, 3);
        System.out.println(Arrays.toString(deleteElementByTarget));*/

        /*int[] noRepeatElement = noRepeatElement(arr);
        System.out.println(Arrays.toString(noRepeatElement));*/

        //bubbleSort(arr);
        /*selectionSort(arr);
        System.out.println(Arrays.toString(arr));*/

        //int[] insertionSort = insertionSort(arr);
        //System.out.println(Arrays.toString(insertionSort));
    }

    /**
     * 获取数组中的最大值
     */
    public static Integer maxElement(int[] arr) {
        /**
         * 关于方法的参数,一般都需要进行两种不同的判断:
         * 1.非空判断,即判断是否为null,避免空指针异常: java.lang.NullPointerException(基本类型不需要判断非空)
         * 2.参数有效性判断,即参数是否符合业务逻辑
         */
        if (arr == null) {
            return null;
        }
        //假设第一个元素是最大的
        Integer max = arr[0];
        //循环从第二个元素开始依次和max比较
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                //覆盖max
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 获取数组中的最小值
     */
    public static Integer minElement(int[] arr) {
        if(arr == null){
            return null;
        }
        Integer min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    /**
     * 添加数组元素
     * @param arr           原数组
     * @param pos           添加元素的下标位置
     * @param newElement    添加的元素
     * @return 添加元素后的新数组
     */
    public static int[] addElement(int[] arr, int pos, int newElement) {
        //判断数组是否为空
        if (arr == null) {
            System.out.println("数组参数不能为空!");
            return null;
        }
        //参数有效性判断
        if (pos < 0 || pos > arr.length) {
            //说明添加的下标不在合理范围之内,就返回原数组
            System.out.println("添加元素的下标位置不合法!");
            return arr;
        }
        //创建新数组,长度+1
        int[] newArr = new int[arr.length + 1];
        //分段法
        //插入点之前
        for (int i = 0; i < pos; i++) {
            newArr[i] = arr[i];
        }
        //插入点
        newArr[pos] = newElement;
        //插入点之后
        for (int i = pos; i < arr.length; i++) {
            newArr[i + 1] = arr[i];
        }
        return newArr;
    }

    /**
     * 根据下标删除数组中的元素(0,1个)
     * @param arr           原数组
     * @param index         被删除元素所在的下标
     * @return 删除元素后的新数组
     */
    public static int[] deleteElementByIndex(int[] arr, int index) {
        //判断数组是否为空
        if (arr == null) {
            System.out.println("数组参数不能为空!");
            return null;
        }
        //参数有效性判断
        if (index < 0 || index >= arr.length) {
            //说明添加的下标不在合理范围之内,就返回原数组
            System.out.println("删除元素的下标不合法!");
            return arr;
        }
        //创建一个新数组,长度为原数组长度-1
        int[] newArr = new int[arr.length - 1];
        //定义一个变量记录新数组的下标
        int idx = 0;
        //遍历原数组
        for (int i = 0; i < arr.length; i++) {
            if (i != index) {
                newArr[idx++] = arr[i];
            }
        }
        return newArr;
    }

    /**
     * 根据元素删除数组中的元素(0,多个)
     * @param arr           原数组
     * @param target        删除的目标元素
     * @return 删除元素后的新数组
     */
    public static int[] deleteElementByTarget(int[] arr, int target) {
        //判断数组是否为空
        if (arr == null) {
            System.out.println("数组参数不能为空!");
            return null;
        }
        //判断数组中有多少个target元素要删除
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                count++;
            }
        }
        //根据计算出要删除的元素个数来新建数组
        int[] newArr = new int[arr.length - count];
        //循环元素组,把不要删除的元素放入到新数组中
        int idx = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != target) {
                newArr[idx++] = arr[i];
            }
        }
        return newArr;
    }

    /**
     * 数组元素排重
     * @param arr       原数组
     * @return 排重后的结果
     */
    public static int[] noRepeatElement(int[] arr) {
        //创建新数组,长度等于原数组
        int[] newArr = new int[arr.length];
        int idx = 0;
        do {
            //把原数组第一个元素放入到新数组中
            newArr[idx++] = arr[0];
            //删除原数组中所有该元素
            arr = deleteElementByTarget(arr, arr[0]);
        } while (arr.length != 0);
        //处理新数组的长度
        newArr = Arrays.copyOf(newArr, idx);
        return newArr;
    }

    /**
     * 冒泡排序
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

    /**
     * 选择排序
     */
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minIdx = i;
            for (int j = i; j < arr.length; j++) {
                if (arr[j] < arr[minIdx]) {
                    minIdx = j;
                }
            }
            if (minIdx != i) {
                int temp = arr[minIdx];
                arr[minIdx] = arr[i];
                arr[i] = temp;
            }
        }
    }

    /**
     * 插入排序
     * https://www.cnblogs.com/onepixel/articles/7674659.html
     */
    public static int[] insertionSort(int[] arr) {
        int i, j, temp;
        for (i = 1; i < arr.length; i++) {
            temp = arr[i];
            for (j = i - 1; j >= 0; j--) {
                if (temp > arr[j]) {
                    break;
                } else {
                    arr[j + 1] = arr[j];
                }
            }
            arr[j + 1] = temp;
        }
        return arr;
    }
}